home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 207_01 / checka.c < prev    next >
Text File  |  1980-01-01  |  19KB  |  607 lines
  1. /*  checka.c -- 2nd source file for check register program                   */
  2.  
  3. /*  copyright (c) 1986 by Jim Woolley and WoolleyWare, San Jose, CA          */
  4.  
  5. /*  vers. 1.0, 12/85 thru 5/86
  6.  */
  7.  
  8. /*  this file contains:
  9.  *      control()
  10.  *      char chek( c, p)
  11.  *      char eddate( c)
  12.  *      char edpayee( c)
  13.  *      char edcategory( c)
  14.  *      char edamount( c)
  15.  *      char eddeposit( c)
  16.  *      char edclear( c)
  17.  *      char edbbf( c)
  18.  */
  19.  
  20. #include    "a:checks.h"
  21.  
  22. control()                               /*  control entry display and edit   */
  23. {
  24.     char c, cwitch, shocommand, s[ 6], chek();
  25.     int i, oldrecno;
  26.  
  27.     shocommand = FALSE;                 /*  initialize                       */
  28.     oldrecno = -1;
  29.     FOREVER
  30.     {
  31.         if ( shocommand || oldrecno != Recno)
  32.         {
  33.             strcpy( s, CLRCOM);
  34.             formatd( s, 3, ( Recno + 1));
  35.             cursorto( 0, 0);
  36.             putscr( Ivon);
  37.             puts( s);                   /*  display Recno and clear command  */
  38.             putscr( Ivoff);
  39.             oldrecno = Recno;
  40.             shocommand = TRUE;
  41.         }
  42.         putquery();
  43.         putcursor( Recno, Field);
  44.         c = chek( getchar(), &shocommand);  /*  wait for command             */
  45.         if ( Recno > Maxentry)          /*  if beyond max entry, skip edit   */
  46.             Oldfield = -1;
  47.         else if ( isibbf( Recno))       /*  else, if a BBF entry             */
  48.         {
  49.             c = edbbf( c);  
  50.             Oldfield = -1;
  51.         }
  52.         else                            /*  else, not a BBF entry            */
  53.         {
  54.             cwitch = Field;
  55.             switch ( cwitch)
  56.             {
  57.             case MMFIELD:  case DDFIELD:  case YYFIELD:
  58.                 c = chek( eddate( c), &shocommand);
  59.                 break;
  60.             case PAYFIELD:
  61.                 c = edpayee( c);
  62.                 break;
  63.             case CATFIELD:
  64.                 c = edcategory( c);
  65.                 break;
  66.             case AMTFIELD:
  67.                 c = chek( edamount( c), &shocommand);
  68.                 break;
  69.             case DEPFIELD:
  70.                 c = eddeposit( c);
  71.                 break;
  72.             case CLRFIELD:
  73.                 c = edclear( c);
  74.                 break;
  75.             }
  76.             Oldfield = Field;
  77.         }
  78.         switch( c)
  79.         {
  80.         case 0:
  81.             break;
  82.         case CTRLD:  case '\r':  case CTRLF:  case '\t':
  83.             goright( c);
  84.             break;
  85.         case CTRLS:  case '\b':  case CTRLA:
  86.             goleft( c);
  87.             break;
  88.         case CTRLX:  case CTRLZ:
  89.             godown( c);
  90.             break;
  91.         case CTRLE:  case CTRLW:
  92.             goup( c);
  93.             break;
  94.         case CTRLC:
  95.             gonext();
  96.             break;
  97.         case CTRLR:
  98.             goprior();
  99.             break;
  100.         case CTRLY:
  101.             delete();
  102.             break;
  103.         case CTRLU:
  104.             undo();
  105.             break;
  106.         case CTRLN:
  107.             Today.yy = 0;               /*  use date of previous entry       */
  108.             insert();
  109.             break;
  110.         case CTRLP:
  111.             print();
  112.             break;
  113.         case CTRLB:  case CTRLO:
  114.             order( Recno);
  115.             break;
  116.         case CTRLQ:  case CTRLK:
  117.             ctrlqork();
  118.             break;
  119.         case CTRLV:
  120.             if ( Field == PAYFIELD)
  121.             {
  122.                 Inserton = !Inserton;
  123.                 Oldfield = -1;
  124.                 break;                  /*  break switch                     */
  125.             }                           /*  else fall thru                   */
  126.         default:
  127.             putchar( BEL);
  128.             break;
  129.         }
  130.     }
  131. }
  132.  
  133. char chek( c, p)                        /*  check and return c               */
  134. char c, *p;                             /*  update *p                        */
  135. {
  136.     if ( c == CTRLJ)
  137.         c = help();                     /*  display help screen              */
  138.     if ( *p = putcommand( c))
  139.         putcursor( Recno, Field);
  140.     return ( c);
  141. }
  142.  
  143. char eddate( c)                         /*  edit MM/DD/YY fields             */
  144. char c;
  145. {
  146.     char cwitch, count, new;
  147.     int ic;
  148.     struct record *e;
  149.  
  150.     if ( c == CTRLU)
  151.         return ( CTRLU);                /*  undo delete                      */
  152.     e = &Entry[ Recno];
  153.     cwitch = Field;
  154.     switch ( cwitch)
  155.     {
  156.     case MMFIELD:
  157.         ic = e->date.mm;
  158.         break;
  159.     case DDFIELD:
  160.         ic = e->date.dd;
  161.         break;
  162.     case YYFIELD:
  163.         ic = e->date.yy;
  164.         break;
  165.     }
  166.     new = TRUE;
  167.     if ( ic < 10)
  168.         count = 1;
  169.     else count = 2;
  170.     FOREVER
  171.     {
  172.         if ( c == '/')
  173.             c = '\r';
  174.         if ( isdigit( c) && ( count < 2 || new))
  175.         {
  176.             if ( new)
  177.             {
  178.                 count = ic = 0;
  179.                 putchar( '\b');
  180.                 putchar( ' ');
  181.                 new = FALSE;
  182.             }
  183.             if ( ic)
  184.             {
  185.                 putchar( '\b');
  186.                 putchar( '0' + ic);
  187.             }
  188.             putchar( c);
  189.             putchar( '\b');
  190.             ic = 10*ic + c - '0';
  191.             ++count;
  192.         }
  193.         else if ( c == CTRLG || c == CTRL_ || c == DEL)
  194.         {
  195.             if ( count)
  196.             {
  197.                 putchar( '\b');
  198.                 putchar( ' ');
  199.                 ic /= 10;
  200.                 if ( --count && ic)
  201.                     putchar( '0' + ic);
  202.                 else putchar( ' ');
  203.                 putchar( '\b');
  204.                 new = FALSE;
  205.             }
  206.             else putchar( BEL);
  207.         }
  208.         else if ( c == CTRLU)
  209.         {
  210.             putrecord( Recno);
  211.             putcursor( Recno, Field);
  212.             return ( 0);
  213.         }
  214.         else if ( iscntrl( c))
  215.         {
  216.             if ( new)
  217.                 return ( c);
  218.             if ( Field != MMFIELD && ic < 10)
  219.             {
  220.                 putchar( '\b');
  221.                 putchar( '0');
  222.             }
  223.             if ( !ic)
  224.                 putchar( '0');
  225.             break;                      /*  break FOREVER                    */
  226.         }
  227.         else putchar( BEL);
  228.         c = getchar();                  /*  get another character            */
  229.     }                                   /*  end FOREVER                      */
  230.     switch ( cwitch)
  231.     {
  232.     case MMFIELD:
  233.         e->date.mm = ic;
  234.         break;
  235.     case DDFIELD:
  236.         e->date.dd = ic;
  237.         break;
  238.     case YYFIELD:
  239.         e->date.yy = ic;
  240.         break;
  241.     }
  242.     Modified = TRUE;
  243.     return ( c);
  244. }
  245.  
  246. char edpayee( c)                        /*  edit payee field                 */
  247. char c;
  248. {
  249.     char *p, *ep, s[ 4], test, past;
  250.     int len, count;
  251.     struct nlist *np;
  252.  
  253.     p = ( ep = Entry[ Recno].payee) + Character;
  254.     len = strlen( ep);
  255.     if ( isprint( c) && len < ( PAYEESIZE - 1))
  256.     {
  257.         strcpy( Savpayee, ep);
  258.         if ( Inserton)
  259.         {
  260.             movmem( p, ( p + 1), ( len - Character + 1));
  261.             *p = c;
  262.             puts( p);
  263.         }
  264.         else putchar( *p = c);
  265.         ++Character;
  266.         if (( len + 1) == 3)
  267.         {
  268.             strcpy(( p = s), ep);
  269.             while ( *p = toupper( *p))
  270.                 ++p;
  271.             if ( np = lookup( s))
  272.             {
  273.                 for ( count = 5*Dloop; count && !kbhit(); --count)
  274.                     continue;           /*  wait 0.5 sec for key             */
  275.                 if ( !count)            /*  if no key, expand abreviation    */
  276.                 {
  277.                     strcpy( ep, np->fullname);
  278.                     putrecord( Recno);
  279.                     Character = strlen( ep);
  280.                 }
  281.             }
  282.         }
  283.     }
  284.     else if ( c == CTRLG && Character < len)
  285.     {
  286.         strcpy( Savpayee, ep);
  287.         movmem(( p + 1), p, ( len - Character));
  288.         puts( p);
  289.         putchar( PAYEEFILL);
  290.     }
  291.     else if (( c == CTRL_ || c == DEL) && Character)
  292.     {
  293.         strcpy( Savpayee,